package org.ykh.gmall.product.service.impl;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.ykh.gmall.common.service.cache.GmallCache;
import org.ykh.gmall.common.service.constant.RedisConst;
import org.ykh.gmall.product.dto.CategoryDto;
import org.ykh.gmall.product.mapper.*;
import org.ykh.gmall.product.*;
import org.ykh.gmall.product.service.ManagerService;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Service
@SuppressWarnings("all")
public class ManagerServiceImpl implements ManagerService {

    @Autowired
    private BaseCategory1Mapper baseCategory1Mapper;


    @Autowired
    private BaseCategory2Mapper baseCategory2Mapper;

    @Autowired
    private BaseCategory3Mapper baseCategory3Mapper;

    @Autowired
    private BaseAttrInfoMapper baseAttrInfoMapper;

    @Autowired
    private BaseAttrValueMapper baseAttrValueMapper;

    @Autowired
    private SpuInfoMapper spuInfoMapper;

    @Autowired
    private BaseSaleAttrMapper baseSaleAttrMapper;

    @Autowired
    private SpuSaleAttrMapper spuSaleAttrMapper;
    @Autowired
    private SpuSaleAttrValueMapper spuSaleAttrValueMapper;
    @Autowired
    private SpuImageMapper spuImageMapper;
    @Autowired
    private SpuPosterMapper spuPosterMapper;

    @Autowired
    private SkuInfoMapper skuInfoMapper;
    @Autowired
    private SkuImageMapper skuImageMapper;
    @Autowired
    private SkuSaleAttrValueMapper skuSaleAttrValueMapper;
    @Autowired
    private SkuAttrValueMapper skuAttrValueMapper;

    @Autowired
    private BaseCategoryViewMapper baseCategoryViewMapper;

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private RedissonClient redisson;

    /**
     *  获取一级分类数据
     * @return
     */
    @Override
    public List<BaseCategory1> getCategory1() {

        //查询所有
        List<BaseCategory1> baseCategory1List = baseCategory1Mapper.selectList(null);

        return baseCategory1List;
    }

    /**
     * 根据一级分类id获取二级分类数据
     * @param category1Id
     * @return
     */
    @Override
    public List<BaseCategory2> getCategory2(Long category1Id) {

        //封装条件
        //select *from base_category2 where category1_id =category1Id;
//        QueryWrapper<BaseCategory2> queryWrapper=new QueryWrapper<>();
//        queryWrapper.eq("category1_id",category1Id);

        LambdaQueryWrapper<BaseCategory2> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(BaseCategory2::getCategory1Id,category1Id);


        List<BaseCategory2> category2List = baseCategory2Mapper.selectList(queryWrapper);
        return category2List;
    }

    /**
     * 根据二级分类id获取三级分类数据
     * @param category2Id
     * @return
     */
    @Override
    public List<BaseCategory3> getCategory3(Long category2Id) {

        LambdaQueryWrapper<BaseCategory3> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(BaseCategory3::getCategory2Id,category2Id);

        List<BaseCategory3> category3List = baseCategory3Mapper.selectList(queryWrapper);
        return category3List;
    }

    /**
     * 根据分类Id 获取平台属性集合
     * @param category1Id
     * @param category2Id
     * @param category3Id
     * @return
     */
    @Override
    public List<BaseAttrInfo> attrInfoList(Long category1Id, Long category2Id, Long category3Id) {

        List<BaseAttrInfo> attrInfoList=  baseAttrInfoMapper.selectAttrInfoList(
                 category1Id,
                 category2Id,
                 category3Id);


        return attrInfoList;
    }

    /**
     * 保存-修改平台属性
     * @param baseAttrInfo
     *
     * 特点：
     * 保存和修改使用同一个接口
     * 区别：
     *  是否存在id
     *
     *  存在：修改  修改数据之前有个回显，回显是从数据库中查询
     *  不存在：添加
     *
     *  新增：
     *    1.添加到base_attr_info
     *    2.添加到base_attr_value
     *
     * 问题：
     *  因为操作多张表，一个完成操作时执行多条sql，如果在过程中出现问题，如何处理？
     *
     * 使用事务操作
     *
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveAttrInfo(BaseAttrInfo baseAttrInfo) {

        //判断
        if(baseAttrInfo.getId()!=null){
            //修改
            baseAttrInfoMapper.updateById(baseAttrInfo);

            //删除对应的属性值
            QueryWrapper<BaseAttrValue> queryWrapper=new QueryWrapper<>();
            queryWrapper.eq("attr_id",baseAttrInfo.getId());

            baseAttrValueMapper.delete(queryWrapper);


        }else{
            //新增
            baseAttrInfoMapper.insert(baseAttrInfo);

        }


        //新增base_attr_value
        for (BaseAttrValue baseAttrValue : baseAttrInfo.getAttrValueList()) {

            //设置平台属性的id
            baseAttrValue.setAttrId(baseAttrInfo.getId());
            baseAttrValueMapper.insert(baseAttrValue);

        }



    }

    /**
     * 根据平台属性Id 获取到平台属性值集合
     * @param attrId
     * @return
     */
    @Override
    public BaseAttrInfo getAttrValueList(Long attrId) {

        //查询平台属性对象
        BaseAttrInfo baseAttrInfo = baseAttrInfoMapper.selectById(attrId);
        //查询平台属性值集合
        LambdaQueryWrapper<BaseAttrValue> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(BaseAttrValue::getAttrId,attrId);

        List<BaseAttrValue> baseAttrValueList = baseAttrValueMapper.selectList(queryWrapper);
        //封装属性值到数据中
        if(baseAttrInfo!=null){

            baseAttrInfo.setAttrValueList(baseAttrValueList);
            return baseAttrInfo;
        }

        return null;
    }

    /**
     * spuInfo分页列表
     * @param spuInfoPage
     * @param spuInfo
     * @return
     */
    @Override
    public IPage<SpuInfo> findSpuListByPage(Page<SpuInfo> spuInfoPage, SpuInfo spuInfo) {

        //创建查询条件对象
        LambdaQueryWrapper<SpuInfo> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(SpuInfo::getCategory3Id,spuInfo.getCategory3Id());

        IPage<SpuInfo>  spuInfoIPage = spuInfoMapper.selectPage(spuInfoPage, queryWrapper);

        return spuInfoIPage;
    }

    /**
     * 获取销售属性集合
     * @return
     */
    @Override
    public List<BaseSaleAttr> baseSaleAttrList() {

        return baseSaleAttrMapper.selectList(null);
    }

    /**
     * 保存spuInfo
     * @param spuInfo
     * spuInfo涉及到的表：
     *
     * spu_info
     * spu_sale_attr
     * spu_sale_attr_value
     * spu_image
     * spu_poster
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveSpuInfo(SpuInfo spuInfo) {

        //保存spuInfo
        spuInfoMapper.insert(spuInfo);

        //保存图片
        List<SpuImage> spuImageList = spuInfo.getSpuImageList();
        //判断
        if(!CollectionUtils.isEmpty(spuImageList)){

            spuImageList.forEach(spuImage -> {
                //设置spuId
                spuImage.setSpuId(spuInfo.getId());
                spuImageMapper.insert(spuImage);
            });

        }

        //保存海报
        List<SpuPoster> spuPosterList = spuInfo.getSpuPosterList();
        //判断
        if(!CollectionUtils.isEmpty(spuPosterList)){

            spuPosterList.forEach(spuPoster -> {
                //设置spuId
                spuPoster.setSpuId(spuInfo.getId());

                spuPosterMapper.insert(spuPoster);
            });
        }


        //保存销售属性
        List<SpuSaleAttr> spuSaleAttrList = spuInfo.getSpuSaleAttrList();
        //判断
        if(!CollectionUtils.isEmpty(spuSaleAttrList)){

            spuSaleAttrList.forEach(spuSaleAttr -> {

                spuSaleAttr.setSpuId(spuInfo.getId());

                spuSaleAttrMapper.insert(spuSaleAttr);


                //保存销售属性值
                List<SpuSaleAttrValue> spuSaleAttrValueList = spuSaleAttr.getSpuSaleAttrValueList();
                //判断
                if(!CollectionUtils.isEmpty(spuSaleAttrValueList)){

                    spuSaleAttrValueList.forEach(spuSaleAttrValue -> {

                        //设置spuId
                        spuSaleAttrValue.setSpuId(spuInfo.getId());
                        //设置属性名
                        spuSaleAttrValue.setSaleAttrName(spuSaleAttr.getSaleAttrName());
                        spuSaleAttrValueMapper.insert(spuSaleAttrValue);

                    });


                }

            });
        }


    }

    /**
     * 根据spuId 获取spuImage 集合
     * @param spuId
     * @return
     */
    @Override
    public List<SpuImage> spuImageList(Long spuId) {

        //select *from spu_image where spu_id=?
        //封装查询条件对象
        LambdaQueryWrapper<SpuImage> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(SpuImage::getSpuId,spuId);

        //执行查询
        List<SpuImage> spuImageList = spuImageMapper.selectList(queryWrapper);

        return spuImageList;
    }

    /**
     * 根据spuId 查询销售属性
     * @param spuId
     * @return
     */
    @Override
    public List<SpuSaleAttr> spuSaleAttrList(Long spuId) {
        List<SpuSaleAttr> spuSaleAttrList=spuSaleAttrMapper.selectSpuSaleAttrList(spuId);

        return spuSaleAttrList;
    }

    /**
     *  保存skuInfo
     *
     * 涉及到的表
     * sku_info
     * sku_image
     * sku_sale_attr_value
     * sku_attr_value
     *
     *
     * @param skuInfo
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveSkuInfo(SkuInfo skuInfo) {

        //保存sku_id
        skuInfoMapper.insert(skuInfo);

        //获取图片集合
        List<SkuImage> skuImageList = skuInfo.getSkuImageList();
        //判断
        if(!CollectionUtils.isEmpty(skuImageList)){
            skuImageList.forEach(skuImage -> {

                //设置skuId
                skuImage.setSkuId(skuInfo.getId());
                //保存图片
                skuImageMapper.insert(skuImage);
            });

        }



        //保存
        List<SkuSaleAttrValue> skuSaleAttrValueList = skuInfo.getSkuSaleAttrValueList();
        //判断
        if(!CollectionUtils.isEmpty(skuSaleAttrValueList)){
            skuSaleAttrValueList.forEach(skuSaleAttrValue -> {

                skuSaleAttrValue.setSkuId(skuInfo.getId());
                skuSaleAttrValue.setSpuId(skuInfo.getSpuId());
                skuSaleAttrValueMapper.insert(skuSaleAttrValue);
            });


        }


        //保存品台属性值
        List<SkuAttrValue> skuAttrValueList = skuInfo.getSkuAttrValueList();
        //判断
        if(!CollectionUtils.isEmpty(skuAttrValueList)){
            skuAttrValueList.forEach(skuAttrValue -> {

                skuAttrValue.setSkuId(skuInfo.getId());

                skuAttrValueMapper.insert(skuAttrValue);

            });
        }

//
//        //保存成功后，添加到布隆过滤器
//        RBloomFilter<Object> bloomFilter = redisson.getBloomFilter(RedisConst.SKU_BLOOM_FILTER);
//        //添加数据
//        bloomFilter.add(skuInfo.getId());
    }

    /**
     * sku分页列表
     * @param skuInfoPage
     * @return
     */
    @Override
    public IPage<SkuInfo> findSkuInfoList(Page<SkuInfo> skuInfoPage) {

        //封装排序条件
        QueryWrapper<SkuInfo> queryWrapper= new QueryWrapper<>();
        queryWrapper.orderByDesc("id");

        IPage<SkuInfo> skuInfoPage1 = skuInfoMapper.selectPage(skuInfoPage, queryWrapper);
        return skuInfoPage1;
    }

    /**
     *
     * 商品上架
     */
    @Override
    public void onSale(Long skuId) {

        // update  sku_info set is_sale=1 where id =skuId
        //封装操作对象
        SkuInfo skuInfo=new SkuInfo();
        //设置条件
        skuInfo.setId(skuId);
        //设置修改的数据
        skuInfo.setIsSale(1);

        skuInfoMapper.updateById(skuInfo);
    }

    /**
     * 商品下架
     * @param skuId
     */
    @Override
    public void cancelSale(Long skuId) {

        //封装操作对象
        SkuInfo skuInfo=new SkuInfo();
        //设置条件
        skuInfo.setId(skuId);
        //设置修改的数据
        skuInfo.setIsSale(0);

        skuInfoMapper.updateById(skuInfo);

    }
    /**
     * 根据skuId获取SkuInfo
     * @param skuId
     * @return
     */
    @Override
    @GmallCache(prefix = "sku:",suffix = ":info")
    public SkuInfo getSkuInfo(Long skuId) {
        //查询skuInfo
        SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
        //查询skuId对应图片集合
        LambdaQueryWrapper<SkuImage> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(SkuImage::getSkuId,skuId);
        List<SkuImage> skuImages = skuImageMapper.selectList(queryWrapper);
        //设置图片列表
        skuInfo.setSkuImageList(skuImages);

        return skuInfo;
    }

    /**
     * redisson优化skuInfo
     * @param skuId
     * @return
     * redisson 优化详情获取数据思路：
     * 思路：
     *  1.首先尝试从redis中获取数据
     *       定义key,获取数据
     *       有：直接返回
     *       没有
     *       2.尝试获取锁
     *        没有：自旋
     *        有
     *        3.尝试从mysql中查询
     *          有：存储到redis ，返回
     *          没有： 存储null, 返回
     *          4.释放锁
     *
     * 5. 兜底方法-直接从mysql中查询
     *
     */
    private SkuInfo getSkuInfoRedisson(Long skuId) {
        try {
            //定义skuInfo的存储key sku:25:info  SkuInfo
            String skuKey= RedisConst.SKUKEY_PREFIX+skuId+RedisConst.SKUKEY_SUFFIX;
            //从redis中尝试获取数据
            SkuInfo skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
            //判断
            if(skuInfo==null){
                //缓存中没有数据，直接获取锁，再查数据库 sku:25:lock
                String lockKey=RedisConst.SKUKEY_PREFIX+skuId+RedisConst.SKULOCK_SUFFIX;
                //获取锁
                RLock lock = redisson.getLock(lockKey);
                //加锁
                boolean result = lock.tryLock(RedisConst.SKULOCK_EXPIRE_PX1, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
                //判断
                if(result){
                    try {
                        //获取到了锁，从mysql中查询数据
                        skuInfo = getSkuInfoDB(skuId);
                        //判断
                        if(skuInfo==null){
                            //创建一个空对象
                            skuInfo=new SkuInfo();

                            //此时从mysql中获取的数据为null,说明用户访问了不存在的key,避免缓存穿透，存储null
                            redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TEMPORARY_TIMEOUT, TimeUnit.SECONDS);

                            return skuInfo;

                        }else {
                            //从mysql中查询获取到了数据,存储redis，返回

                            redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
                            return skuInfo;
                        }
                    } finally {

                        //释放锁
                        lock.unlock();
                    }


                }else{
                    //没有获取到锁
                    Thread.sleep(100);
                    return getSkuInfoRedisson(skuId);

                }

            }else{
                //缓存中有数据，直接返回
                return skuInfo;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        //兜底方法，查询数据库
        return getSkuInfoDB(skuId);
    }

    /**
     * reids实现获取详情数据
     * @param skuId
     * @return
     *
     * redis 优化详情获取数据思路：
     * 思路：
     *  1.首先尝试从redis中获取数据
     *       定义key,获取数据
     *       有：直接返回
     *       没有
     *       2.尝试获取锁
     *        没有：自旋
     *        有
     *        3.尝试从mysql中查询
     *          有：存储到redis ，返回
     *          没有： 存储null, 返回
     *          4.释放锁
     *
     * 5. 兜底方法-直接从mysql中查询
     *
     *
     */
    private SkuInfo getSkuInfoRedis(Long skuId) {

        try {
            //定义skuInfo的存储key sku:25:info  SkuInfo
            String skuKey= RedisConst.SKUKEY_PREFIX+skuId+RedisConst.SKUKEY_SUFFIX;
            //从redis中尝试获取数据
            SkuInfo skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
            //判断
            if(skuInfo==null){
                //定义锁的key sku:25:lock
                String lockKey=RedisConst.SKUKEY_PREFIX+skuId+RedisConst.SKULOCK_SUFFIX;
                //生成不可猜测的随机锁值
                String uuId = UUID.randomUUID().toString().replaceAll("-", "");
                //尝试获取锁-防止缓存击穿的问题
                Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, uuId, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
                //判断是否获取到了锁
                if(result){
                    try {
                        //获取到了锁，从mysql中查询数据
                        skuInfo = getSkuInfoDB(skuId);
                        //判断
                        if(skuInfo==null){
                            //创建一个空对象
                            skuInfo=new SkuInfo();

                            //此时从mysql中获取的数据为null,说明用户访问了不存在的key,避免缓存穿透，存储null
                            redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);

                            return skuInfo;

                        }else {
                            //从mysql中查询获取到了数据,存储redis，返回

                            redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
                            return skuInfo;
                        }
                    } finally {
                        //释放锁
                        //lua脚本删除
                        //定义lua脚本
                        String script="if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
                                "then\n" +
                                "    return redis.call(\"del\",KEYS[1])\n" +
                                "else\n" +
                                "    return 0\n" +
                                "end";

                        //创建脚本对象
                        DefaultRedisScript<Long> redisScript=new DefaultRedisScript<>();
                        redisScript.setScriptText(script);
                        redisScript.setResultType(Long.class);
                        //执行删除
                        redisTemplate.execute(redisScript, Arrays.asList(lockKey),uuId);
                    }
                }else{

                    //在获取锁时，没有获取到，尝试自旋获取
                    try {
                        //睡眠
                        Thread.sleep(100);
                        //自旋
                        return getSkuInfoRedis(skuId);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }



            }else {
                //从redis中获取了数据
                return  skuInfo;

            }
        } catch (Exception e) {
            e.printStackTrace();
        }


        //兜底方法-如果在操作过程中redis出现问题，可以直接查询mysql
        return getSkuInfoDB(skuId);
    }



    /**
     * 查询数据库获取数据
     * @param skuId
     * @return
     */
    private SkuInfo getSkuInfoDB(Long skuId) {
        //查询skuInfo
        SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
        //查询skuId对应图片集合
        LambdaQueryWrapper<SkuImage> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(SkuImage::getSkuId,skuId);
        List<SkuImage> skuImages = skuImageMapper.selectList(queryWrapper);
        //设置图片列表
        if(skuInfo!=null){
            skuInfo.setSkuImageList(skuImages);
        }

        return skuInfo;
    }


    /**
     * 根据skuId 获取最新的商品价格
     * @param skuId
     * @return
     */
    @Override
    public BigDecimal getskuPrice(Long skuId) {
        //查询sku
        SkuInfo skuInfo = skuInfoMapper.selectById(skuId);

        //判断
        if(skuInfo!=null){
            return skuInfo.getPrice();
        }

        return new BigDecimal("0");
    }

    /**
     * 根据三级分类id获取分类信息
     * @param category3Id
     * @return
     */
    @Override
    public BaseCategoryView getCategoryView(Long category3Id) {

        //查询数据
        BaseCategoryView baseCategoryView = baseCategoryViewMapper.selectById(category3Id);

        return baseCategoryView;
    }

    /**
     * 根据spuId,skuId 获取销售属性数据
     * @param skuId
     * @param spuId
     * @return
     */
    @Override
    public List<SpuSaleAttr> getSpuSaleAttrListCheckBySku(Long skuId, Long spuId) {



        return spuSaleAttrMapper.selectSpuSaleAttrListCheckBySku(skuId,spuId);
    }

    /**
     * 根据spuId 获取海报数据
     * @param spuId
     * @return
     */
    @Override
    public List<SpuPoster> findSpuPosterBySpuId(Long spuId) {

        //select *from spu_poster where spu_id=11
        //封装条件
        LambdaQueryWrapper<SpuPoster> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.eq(SpuPoster::getSpuId,spuId);

        //执行查询
        List<SpuPoster> posterList = spuPosterMapper.selectList(queryWrapper);

        return posterList;
    }

    /**
     * 根据skuId 获取平台属性数据
     * @param skuId
     * @return
     */
    @Override
    public List<BaseAttrInfo> getAttrList(Long skuId) {
        return baseAttrInfoMapper.selectAttrList(skuId);
    }

    /**
     * 根据spuId 获取到销售属性值Id 与skuId 组成的结果集
     * @param spuId
     * @return
     */
    @Override
    public Map getSkuValueIdsMap(Long spuId) {

        //创建封装结果对象
        Map resultMap=new HashMap();

        List<Map> mapList=skuSaleAttrValueMapper.selectSkuValueIdsMap(spuId);
        //判断
        if(!CollectionUtils.isEmpty(mapList)){
            for (Map map : mapList) {
                resultMap.put(map.get("value_ids"),map.get("sku_id"));
            }
        }
        return resultMap;
    }

    @Override
    @GmallCache(prefix = "baseCategoryList:")
    public List<CategoryDto> getBaseCategoryList() {
        baseCategoryViewMapper.resetRowNumbeRselectLevelBefor();
        baseCategoryViewMapper.resetPrevCategory1IdSelectLevelBefor();
        return baseCategoryViewMapper.selectLevel();
    }

//    @Override
//    @GmallCache(prefix = "baseCategoryList:")
//    public List<JSONObject> getBaseCategoryList() {
//
//        //获取所有三级分类数据---必须是有对应关系的
//        List<BaseCategoryView> baseCategoryViewList = baseCategoryViewMapper.selectList(null);
//        //对获取所有数据中的一级分类进行分组
//        Map<Long, List<BaseCategoryView>> category1Map = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory1Id));
//        //定义序号
//        int index=1;
//        //创建一级分类的集合
//        List<JSONObject> category1List=new ArrayList<>();
//
//        //遍历集合
//        for (Map.Entry<Long, List<BaseCategoryView>> category1Entry : category1Map.entrySet()) {
//
//            //创建一级分类的封装对象
//            JSONObject category1Object=new JSONObject();
//            category1Object.put("index",index);
//
//            //category1Entry 一级分类的键值对
//            Long category1Id = category1Entry.getKey();
//            category1Object.put("categoryId",category1Id);
//            //获取一级分类名称
//            String category1Name = category1Entry.getValue().get(0).getCategory1Name();
//            category1Object.put("categoryName",category1Name);
//
//            //获取当前一级分类对应的所有二级分类
//            List<BaseCategoryView> category2List = category1Entry.getValue();
//            //根据二级分类id进行分组
//            Map<Long, List<BaseCategoryView>> category2Map = category2List.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
//
//            //创建集合收集二级分类
//            List<JSONObject> list2Category=new ArrayList<>();
//            //遍历二级分类
//            for (Map.Entry<Long, List<BaseCategoryView>> category2Entry : category2Map.entrySet()) {
//                //创建二级分类的封装对象
//                JSONObject category2Object=new JSONObject();
//
//                //获取二级分类id
//                Long category2Id = category2Entry.getKey();
//                category2Object.put("categoryId",category2Id);
//                //获取二级分类名称
//                String category2Name = category2Entry.getValue().get(0).getCategory2Name();
//                category2Object.put("categoryName",category2Name);
//
//                //创建集合收集三级分类数据
//                List<JSONObject> list3Category=new ArrayList<>();
//
//                //从当前遍历的二级分类中获取对应的三级分类集合
//                List<BaseCategoryView> category3List = category2Entry.getValue();
//                for (BaseCategoryView baseCategoryView : category3List) {
//                    JSONObject category3Object=new JSONObject();
//                    //封装三级分类id
//                    category3Object.put("categoryId",baseCategoryView.getCategory3Id());
//                    category3Object.put("categoryName",baseCategoryView.getCategory3Name());
//
//                    list3Category.add(category3Object);
//
//                }
//
//
//                //封装三级分类集合
//                category2Object.put("categoryChild",list3Category);
//                list2Category.add(category2Object);
//
//
//            }
//
//
//
//            //设置二级分类集合到一级对象中
//            category1Object.put("categoryChild",list2Category);
//            index++;
//            //收集一级分类数据
//            category1List.add(category1Object);
//        }
//
//        return category1List;
//    }

}
